<!doctype html>
<html lang="zh-CN">
<head>
  <base href="https://www.nodeapp.cn/child_process.html" />
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width">
  <title>子进程 | Node.js 中文文档 | Node.js 中文网</title>
  <meta name="description" content="Node.js 是一个基于 Chrome V8 引擎的 JavaScript 运行环境。Node.js 使用了一个事件驱动、非阻塞式 I/O 的模型，使其轻量又高效。Node.js 的包管理器 npm，是全球最大的开源库生态系统。">
  <link rel="stylesheet" href="assets/style.css">
  <link rel="stylesheet" href="assets/sh.css">
  <link rel="canonical" href="https://www.nodeapp.cn/child_process.html">
  <link rel="apple-touch-icon" href="apple-touch-icon.png">
  <link rel="icon" sizes="32x32" type="image/png" href="favicon.png">
  
  <script>
var _hmt = _hmt || [];
(function() {
  var hm = document.createElement("script");
  hm.src = "https://hm.baidu.com/hm.js?acdf78480f7f8f2b23b812565a5868e0";
  var s = document.getElementsByTagName("script")[0]; 
  s.parentNode.insertBefore(hm, s);
})();
</script>

</head>
<body class="alt apidoc" id="api-section-child_process">
  <div id="content" class="clearfix">
    <div id="column1" data-id="child_process" class="interior">
      <header>
        <h1>Node.js v8.x 中文文档</h1>
        <hr>
      </header>

      <div id="toc">
        <h2>目录</h2>
        <ul>
<li><span class="stability_2"><a href="#child_process_child_process">child_process - 子进程</a></span><ul>
<li><span class="stability_undefined"><a href="#child_process_asynchronous_process_creation">创建异步进程</a></span><ul>
<li><span class="stability_undefined"><a href="#child_process_spawning_bat_and_cmd_files_on_windows">在 Windows 上衍生 <code>.bat</code> 和 <code>.cmd</code> 文件</a></span></li>
<li><span class="stability_undefined"><a href="#child_process_child_process_exec_command_options_callback">child_process.exec(command[, options][, callback])</a></span></li>
<li><span class="stability_undefined"><a href="#child_process_child_process_execfile_file_args_options_callback">child_process.execFile(file[, args][, options][, callback])</a></span></li>
<li><span class="stability_undefined"><a href="#child_process_child_process_fork_modulepath_args_options">child_process.fork(modulePath[, args][, options])</a></span></li>
<li><span class="stability_undefined"><a href="#child_process_child_process_spawn_command_args_options">child_process.spawn(command[, args][, options])</a></span><ul>
<li><span class="stability_undefined"><a href="#child_process_options_detached">options.detached</a></span></li>
<li><span class="stability_undefined"><a href="#child_process_options_stdio">options.stdio</a></span></li>
</ul>
</li>
</ul>
</li>
<li><span class="stability_undefined"><a href="#child_process_synchronous_process_creation">创建同步进程</a></span><ul>
<li><span class="stability_undefined"><a href="#child_process_child_process_execfilesync_file_args_options">child_process.execFileSync(file[, args][, options])</a></span></li>
<li><span class="stability_undefined"><a href="#child_process_child_process_execsync_command_options">child_process.execSync(command[, options])</a></span></li>
<li><span class="stability_undefined"><a href="#child_process_child_process_spawnsync_command_args_options">child_process.spawnSync(command[, args][, options])</a></span></li>
</ul>
</li>
<li><span class="stability_undefined"><a href="#child_process_class_childprocess">ChildProcess 类</a></span><ul>
<li><span class="stability_undefined"><a href="#child_process_event_close">&apos;close&apos; 事件</a></span></li>
<li><span class="stability_undefined"><a href="#child_process_event_disconnect">&apos;disconnect&apos; 事件</a></span></li>
<li><span class="stability_undefined"><a href="#child_process_event_error">&apos;error&apos; 事件</a></span></li>
<li><span class="stability_undefined"><a href="#child_process_event_exit">&apos;exit&apos; 事件</a></span></li>
<li><span class="stability_undefined"><a href="#child_process_event_message">&apos;message&apos; 事件</a></span></li>
<li><span class="stability_undefined"><a href="#child_process_subprocess_channel">subprocess.channel</a></span></li>
<li><span class="stability_undefined"><a href="#child_process_subprocess_connected">subprocess.connected</a></span></li>
<li><span class="stability_undefined"><a href="#child_process_subprocess_disconnect">subprocess.disconnect()</a></span></li>
<li><span class="stability_undefined"><a href="#child_process_subprocess_kill_signal">subprocess.kill([signal])</a></span></li>
<li><span class="stability_undefined"><a href="#child_process_subprocess_killed">subprocess.killed</a></span></li>
<li><span class="stability_undefined"><a href="#child_process_subprocess_pid">subprocess.pid</a></span></li>
<li><span class="stability_undefined"><a href="#child_process_subprocess_send_message_sendhandle_options_callback">subprocess.send(message[, sendHandle[, options]][, callback])</a></span><ul>
<li><span class="stability_undefined"><a href="#child_process_example_sending_a_server_object">例子：发送一个 server 对象</a></span></li>
<li><span class="stability_undefined"><a href="#child_process_example_sending_a_socket_object">例子：发送一个 socket 对象</a></span></li>
</ul>
</li>
<li><span class="stability_undefined"><a href="#child_process_subprocess_stderr">subprocess.stderr</a></span></li>
<li><span class="stability_undefined"><a href="#child_process_subprocess_stdin">subprocess.stdin</a></span></li>
<li><span class="stability_undefined"><a href="#child_process_subprocess_stdio">subprocess.stdio</a></span></li>
<li><span class="stability_undefined"><a href="#child_process_subprocess_stdout">subprocess.stdout</a></span></li>
</ul>
</li>
<li><span class="stability_undefined"><a href="#child_process_maxbuffer_and_unicode"><code>maxBuffer</code> 与 Unicode</a></span></li>
<li><span class="stability_undefined"><a href="#child_process_shell_requirements">Shell 的要求</a></span></li>
<li><span class="stability_undefined"><a href="#child_process_default_windows_shell">Windows 默认的 Shell</a></span></li>
</ul>
</li>
</ul>

      </div>
<div id="apicontent">
        <h1>child_process - 子进程<span><a class="mark" href="#child_process_child_process" id="child_process_child_process">#</a></span></h1>
<!--introduced_in=v0.10.0-->
<div class="api_stability api_stability_2"><a href="documentation.html#documentation_stability_index">稳定性: 2</a> - 稳定的</div><p><code>child_process</code> 模块提供了衍生子进程的功能，它与 <a href="http://man7.org/linux/man-pages/man3/popen.3.html">popen(3)</a> 类似，但不完全相同。
这个功能主要由 [<code>child_process.spawn()</code>] 函数提供：</p>
<pre><code class="lang-js">const { spawn } = require(&apos;child_process&apos;);
const ls = spawn(&apos;ls&apos;, [&apos;-lh&apos;, &apos;/usr&apos;]);

ls.stdout.on(&apos;data&apos;, (data) =&gt; {
  console.log(`输出：${data}`);
});

ls.stderr.on(&apos;data&apos;, (data) =&gt; {
  console.log(`错误：${data}`);
});

ls.on(&apos;close&apos;, (code) =&gt; {
  console.log(`子进程退出码：${code}`);
});
</code></pre>
<p>默认情况下，Node.js 的父进程与衍生的子进程之间会建立 <code>stdin</code>、<code>stdout</code> 和 <code>stderr</code> 的管道。
数据能以非阻塞的方式在管道中流通。
有些程序会在内部使用行缓冲 I/O，虽然这并不影响 Node.js，但发送到子进程的数据可能无法被立即使用。</p>
<p>[<code>child_process.spawn()</code>] 函数会异步地衍生子进程，且不会阻塞 Node.js 事件循环。
[<code>child_process.spawnSync()</code>] 函数则以同步的方式提供同样的功能，但会阻塞事件循环，直到衍生的子进程退出或被终止。</p>
<p><code>child_process</code> 模块还提供了其他一些同步和异步的可选函数。
每个函数都是基于 [<code>child_process.spawn()</code>] 或 [<code>child_process.spawnSync()</code>] 实现的。</p>
<ul>
<li>[<code>child_process.exec()</code>]: 衍生一个 shell 并在 shell 上运行命令，当完成时会传入 <code>stdout</code> 和 <code>stderr</code> 到回调函数。</li>
<li>[<code>child_process.execFile()</code>]: 类似 [<code>child_process.exec()</code>]，但直接衍生命令，且无需先衍生 shell。</li>
<li>[<code>child_process.fork()</code>]: 衍生一个新的 Node.js 进程，并通过建立 IPC 通讯通道来调用指定的模块，该通道允许父进程与子进程之间相互发送信息。</li>
<li>[<code>child_process.execSync()</code>]: [<code>child_process.exec()</code>] 的同步函数，会阻塞 Node.js 事件循环。</li>
<li>[<code>child_process.execFileSync()</code>]: [<code>child_process.execFile()</code>] 的同步函数，会阻塞 Node.js 事件循环。</li>
</ul>
<p>对于某些特例，如自动化的 shell 脚本，<a href="#child_process_synchronous_process_creation">同步的函数</a>可能更方便。
但大多数情况下，同步的函数会明显影响性能，因为它会拖延事件循环直到衍生进程完成。</p>
<h2>创建异步进程<span><a class="mark" href="#child_process_asynchronous_process_creation" id="child_process_asynchronous_process_creation">#</a></span></h2>
<p>[<code>child_process.spawn()</code>]、[<code>child_process.fork()</code>]、[<code>child_process.exec()</code>] 和 [<code>child_process.execFile()</code>] 函数都遵循 Node.js API 惯用的异步编程模式。</p>
<p>每个函数都返回 [<code>ChildProcess</code>] 实例。
这些实例实现了 Node.js [<code>EventEmitter</code>] API，允许父进程注册监听器函数，在子进程生命周期期间，当特定的事件发生时会调用这些函数。</p>
<p>[<code>child_process.exec()</code>] 和 [<code>child_process.execFile()</code>] 函数可以额外指定一个可选的 <code>callback</code> 函数，当子进程结束时会被调用。</p>
<h3>在 Windows 上衍生 <code>.bat</code> 和 <code>.cmd</code> 文件<span><a class="mark" href="#child_process_spawning_bat_and_cmd_files_on_windows" id="child_process_spawning_bat_and_cmd_files_on_windows">#</a></span></h3>
<p>[<code>child_process.exec()</code>] 和 [<code>child_process.execFile()</code>] 之间的区别会因平台而不同。
在类 Unix 操作系统（Unix、 Linux、 macOS）上，[<code>child_process.execFile()</code>] 效率更高，因为它不需要衍生 shell。
但在 Windows 上，<code>.bat</code> 和 <code>.cmd</code> 文件在没有终端的情况下是不可执行的，因此不能使用 [<code>child_process.execFile()</code>] 启动。
可以使用设置了 <code>shell</code> 选项的 [<code>child_process.spawn()</code>]、或使用 [<code>child_process.exec()</code>]、或衍生 <code>cmd.exe</code> 并将 <code>.bat</code> 或 <code>.cmd</code> 文件作为参数传入（也就是 <code>shell</code> 选项和 [<code>child_process.exec()</code>] 所做的工作）。
如果脚本文件名包含空格，则需要加上引号。</p>
<pre><code class="lang-js">// 仅限 Windows 系统
const { spawn } = require(&apos;child_process&apos;);
const bat = spawn(&apos;cmd.exe&apos;, [&apos;/c&apos;, &apos;my.bat&apos;]);

bat.stdout.on(&apos;data&apos;, (data) =&gt; {
  console.log(data.toString());
});

bat.stderr.on(&apos;data&apos;, (data) =&gt; {
  console.log(data.toString());
});

bat.on(&apos;exit&apos;, (code) =&gt; {
  console.log(`子进程退出码：${code}`);
});
</code></pre>
<pre><code class="lang-js">// 或
const { exec } = require(&apos;child_process&apos;);
exec(&apos;my.bat&apos;, (err, stdout, stderr) =&gt; {
  if (err) {
    console.error(err);
    return;
  }
  console.log(stdout);
});

// 文件名带有空格的脚本：
const bat = spawn(&apos;&quot;my script.cmd&quot;&apos;, [&apos;a&apos;, &apos;b&apos;], { shell: true });
// 或：
exec(&apos;&quot;my script.cmd&quot; a b&apos;, (err, stdout, stderr) =&gt; {
  // ...
});
</code></pre>
<h3>child_process.exec(command[, options][, callback])<span><a class="mark" href="#child_process_child_process_exec_command_options_callback" id="child_process_child_process_exec_command_options_callback">#</a></span></h3>
<div class="api_metadata">
<details class="changelog"><summary>版本历史</summary>
<table>
<tbody><tr><th>版本</th><th>变更</th></tr>
<tr><td>v8.8.0</td>
<td><p>The <code>windowsHide</code> option is supported now.</p>
</td></tr>
<tr><td>v0.1.90</td>
<td><p><span>新增于: v0.1.90</span></p>
</td></tr>
</tbody></table>
</details>
</div><ul>
<li><code>command</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&lt;string&gt;</a> 运行的命令，参数使用空格分隔。</li>
<li><code>options</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&lt;Object&gt;</a><ul>
<li><code>cwd</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&lt;string&gt;</a> 子进程的当前工作目录。</li>
<li><code>env</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&lt;Object&gt;</a> 环境变量键值对。</li>
<li><code>encoding</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&lt;string&gt;</a> 默认为 <code>&apos;utf8&apos;</code>。</li>
<li><code>shell</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&lt;string&gt;</a> 执行命令的 shell。在 UNIX 上默认为 <code>&apos;/bin/sh&apos;</code>，在 Windows 上默认为 <code>process.env.ComSpec</code>。详见<a href="#child_process_shell_requirements">Shell的要求</a>与<a href="#child_process_default_windows_shell">Windows默认的Shell</a>。</li>
<li><code>timeout</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&lt;number&gt;</a> 默认为 <code>0</code>。</li>
<li><code>maxBuffer</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&lt;number&gt;</a> <code>stdout</code> 或 <code>stderr</code> 允许的最大字节数。默认为 <code>200*1024</code>。如果超过限制，则子进程会被终止。详见 <a href="#child_process_maxbuffer_and_unicode"><code>maxBuffer</code>与Unicode</a>。</li>
<li><code>killSignal</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&lt;string&gt;</a> | 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&lt;integer&gt;</a> 默认为 <code>&apos;SIGTERM&apos;</code>。</li>
<li><code>uid</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&lt;number&gt;</a> 设置进程的用户标识，详见 <a href="http://man7.org/linux/man-pages/man2/setuid.2.html">setuid(2)</a>。</li>
<li><code>gid</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&lt;number&gt;</a> 设置进程的组标识，详见 <a href="http://man7.org/linux/man-pages/man2/setgid.2.html">setgid(2)</a>。</li>
<li><code>windowsHide</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&lt;boolean&gt;</a> 隐藏子进程的控制台窗口，常用于 Windows 系统。默认为 <code>false</code>。</li>
</ul>
</li>
<li><code>callback</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&lt;Function&gt;</a> 进程终止时调用。<ul>
<li><code>error</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&lt;Error&gt;</a></li>
<li><code>stdout</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&lt;string&gt;</a> | 
            <a href="buffer.html#buffer_class_buffer" class="type">&lt;Buffer&gt;</a></li>
<li><code>stderr</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&lt;string&gt;</a> | 
            <a href="buffer.html#buffer_class_buffer" class="type">&lt;Buffer&gt;</a></li>
</ul>
</li>
<li>返回: 
            <a href="child_process.html#child_process_class_childprocess" class="type">&lt;ChildProcess&gt;</a></li>
</ul>
<p>衍生一个 shell 并在 shell 中执行 <code>command</code>，且缓冲任何产生的输出。
传入函数的 <code>command</code> 字符串会被 shell 直接处理，特殊字符（<a href="https://en.wikipedia.org/wiki/List_of_command-line_interpreters">因shell而异</a>）需要相应处理：</p>
<pre><code class="lang-js">exec(&apos;&quot;/path/to/test file/test.sh&quot; arg1 arg2&apos;);
// 使用双引号使路径中的空格不会被理解为多个参数。

exec(&apos;echo &quot;The \\$HOME variable is $HOME&quot;&apos;);
// 第一个 $HOME 会被转义，而第二个不会。
</code></pre>
<p>注意：不要把未经检查的用户输入传入到该函数。
任何包括 shell 元字符的输入都可被用于触发任何命令的执行。</p>
<pre><code class="lang-js">const { exec } = require(&apos;child_process&apos;);
exec(&apos;cat *.js bad_file | wc -l&apos;, (error, stdout, stderr) =&gt; {
  if (error) {
    console.error(`exec error: ${error}`);
    return;
  }
  console.log(`stdout: ${stdout}`);
  console.log(`stderr: ${stderr}`);
});
</code></pre>
<p>如果提供了一个 <code>callback</code> 函数，则它被调用时会带上参数 <code>(error, stdout, stderr)</code>。
当成功时，<code>error</code> 会是 <code>null</code>。
当失败时，<code>error</code> 会是一个 [<code>Error</code>] 实例。
<code>error.code</code> 属性会是子进程的退出码，<code>error.signal</code> 会被设为终止进程的信号。
除 <code>0</code> 以外的任何退出码都被认为是一个错误。</p>
<p>传给回调的 <code>stdout</code> 和 <code>stderr</code> 参数会包含子进程的 stdout 和 stderr 的输出。
默认情况下，Node.js 会解码输出为 UTF-8，并将字符串传给回调。
<code>encoding</code> 选项可用于指定用于解码 stdout 和 stderr 输出的字符编码。
如果 <code>encoding</code> 是 <code>&apos;buffer&apos;</code>、或一个无法识别的字符编码，则传入 <code>Buffer</code> 对象到回调函数。</p>
<p><code>options</code> 参数可以作为第二个参数传入，用于自定义如何衍生进程。
默认的选项是：</p>
<pre><code class="lang-js">const defaults = {
  encoding: &apos;utf8&apos;,
  timeout: 0,
  maxBuffer: 200 * 1024,
  killSignal: &apos;SIGTERM&apos;,
  cwd: null,
  env: null
};
</code></pre>
<p>如果 <code>timeout</code> 大于 <code>0</code>，当子进程运行超过 <code>timeout</code> 毫秒时，父进程就会发送由 <code>killSignal</code> 属性标识的信号（默认为 <code>&apos;SIGTERM&apos;</code>）。</p>
<p>注意：不像 POSIX 系统调用中的 <a href="http://man7.org/linux/man-pages/man3/exec.3.html">exec(3)</a>，<code>child_process.exec()</code> 不会替换现有的进程，且使用一个 shell 来执行命令。</p>
<p>如果调用该方法的 [<code>util.promisify()</code>][] 版本，将会返回一个包含 <code>stdout</code> 和 <code>stderr</code> 的 Promise 对象。在出现错误的情况下，将返回 rejected 状态的 promise，拥有与回调函数一样的 <code>error</code> 对象，但附加了 <code>stdout</code> 和 <code>stderr</code> 属性。</p>
<p>例子:</p>
<pre><code class="lang-js">const util = require(&apos;util&apos;);
const exec = util.promisify(require(&apos;child_process&apos;).exec);

async function lsExample() {
  const { stdout, stderr } = await exec(&apos;ls&apos;);
  console.log(&apos;stdout:&apos;, stdout);
  console.log(&apos;stderr:&apos;, stderr);
}
lsExample();
</code></pre>
<h3>child_process.execFile(file[, args][, options][, callback])<span><a class="mark" href="#child_process_child_process_execfile_file_args_options_callback" id="child_process_child_process_execfile_file_args_options_callback">#</a></span></h3>
<div class="api_metadata">
<details class="changelog"><summary>版本历史</summary>
<table>
<tbody><tr><th>版本</th><th>变更</th></tr>
<tr><td>v8.8.0</td>
<td><p>The <code>windowsHide</code> option is supported now.</p>
</td></tr>
<tr><td>v0.1.91</td>
<td><p><span>新增于: v0.1.91</span></p>
</td></tr>
</tbody></table>
</details>
</div><ul>
<li><code>file</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&lt;string&gt;</a> 要运行的可执行文件的名称或路径。</li>
<li><code>args</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&lt;string[]&gt;</a> 字符串参数列表。</li>
<li><code>options</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&lt;Object&gt;</a><ul>
<li><code>cwd</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&lt;string&gt;</a> 子进程的当前工作目录。</li>
<li><code>env</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&lt;Object&gt;</a> 环境变量键值对。</li>
<li><code>encoding</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&lt;string&gt;</a> 默认为 <code>&apos;utf8&apos;</code>。</li>
<li><code>timeout</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&lt;number&gt;</a> 默认为 <code>0</code>。</li>
<li><a href="#child_process_maxbuffer_and_unicode"><code>maxBuffer</code></a> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&lt;number&gt;</a> stdout 或 stderr 允许的最大字节数。
默认为 <code>200*1024</code>。
如果超过限制，则子进程会被终止。
See caveat at [<code>maxBuffer</code> and Unicode][].</li>
<li><code>killSignal</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&lt;string&gt;</a> | 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&lt;integer&gt;</a> 默认为 <code>&apos;SIGTERM&apos;</code>。</li>
<li><code>uid</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&lt;number&gt;</a> 设置该进程的用户标识。（详见 <a href="http://man7.org/linux/man-pages/man2/setuid.2.html">setuid(2)</a>）</li>
<li><code>gid</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&lt;number&gt;</a> 设置该进程的组标识。（详见 <a href="http://man7.org/linux/man-pages/man2/setgid.2.html">setgid(2)</a>）</li>
<li><code>windowsHide</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&lt;boolean&gt;</a> 是否隐藏在Windows系统下默认会弹出的子进程控制台窗口。 <strong>默认为:</strong> <code>false</code>。</li>
<li><code>windowsVerbatimArguments</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&lt;boolean&gt;</a> 决定在Windows系统下是否使用转义参数。 在Linux平台下会自动忽略，当指令 <code>shell</code> 存在的时该属性将自动被设置为true。<strong>默认为:</strong> <code>false</code>。</li>
</ul>
</li>
<li><code>callback</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&lt;Function&gt;</a> 当进程终止时调用，并带上输出。<ul>
<li><code>error</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&lt;Error&gt;</a></li>
<li><code>stdout</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&lt;string&gt;</a> | 
            <a href="buffer.html#buffer_class_buffer" class="type">&lt;Buffer&gt;</a></li>
<li><code>stderr</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&lt;string&gt;</a> | 
            <a href="buffer.html#buffer_class_buffer" class="type">&lt;Buffer&gt;</a></li>
</ul>
</li>
<li>返回: 
            <a href="child_process.html#child_process_class_childprocess" class="type">&lt;ChildProcess&gt;</a></li>
</ul>
<p><code>child_process.execFile()</code> 函数类似 [<code>child_process.exec()</code>]，除了不衍生一个 shell。
而是，指定的可执行的 <code>file</code> 被直接衍生为一个新进程，这使得它比 [<code>child_process.exec()</code>] 更高效。</p>
<p>它支持和 [<code>child_process.exec()</code>] 一样的选项。
由于没有衍生 shell，因此不支持像 I/O 重定向和文件查找这样的行为。</p>
<pre><code class="lang-js">const { execFile } = require(&apos;child_process&apos;);
const child = execFile(&apos;node&apos;, [&apos;--version&apos;], (error, stdout, stderr) =&gt; {
  if (error) {
    throw error;
  }
  console.log(stdout);
});
</code></pre>
<p>传给回调的 <code>stdout</code> 和 <code>stderr</code> 参数会包含子进程的 stdout 和 stderr 的输出。
默认情况下，Node.js 会解码输出为 UTF-8，并将字符串传给回调。
<code>encoding</code> 选项可用于指定用于解码 stdout 和 stderr 输出的字符编码。
如果 <code>encoding</code> 是 <code>&apos;buffer&apos;</code>、或一个无法识别的字符编码，则传入 <code>Buffer</code> 对象到回调函数。</p>
<p>如果调用该方法的 [<code>util.promisify()</code>][] 版本， 它会返回一个拥有 <code>stdout</code> 和
<code>stderr</code> 属性的 Promise 对象. 在发生错误的情况下, 返回一个 rejected 状态的 promise, 拥有与回调
函数一样的 <code>error</code> 对象, 但是附加了 <code>stdout</code> 和 <code>stderr</code> 这两个属性.</p>
<pre><code class="lang-js">const util = require(&apos;util&apos;);
const execFile = util.promisify(require(&apos;child_process&apos;).execFile);
async function getVersion() {
  const { stdout } = await execFile(&apos;node&apos;, [&apos;--version&apos;]);
  console.log(stdout);
}
getVersion();
</code></pre>
<h3>child_process.fork(modulePath[, args][, options])<span><a class="mark" href="#child_process_child_process_fork_modulepath_args_options" id="child_process_child_process_fork_modulepath_args_options">#</a></span></h3>
<div class="api_metadata">
<details class="changelog"><summary>版本历史</summary>
<table>
<tbody><tr><th>版本</th><th>变更</th></tr>
<tr><td>v8.0.0</td>
<td><p>The <code>stdio</code> option can now be a string.</p>
</td></tr>
<tr><td>v6.4.0</td>
<td><p>The <code>stdio</code> option is supported now.</p>
</td></tr>
<tr><td>v0.5.0</td>
<td><p><span>新增于: v0.5.0</span></p>
</td></tr>
</tbody></table>
</details>
</div><ul>
<li><code>modulePath</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&lt;string&gt;</a> 要在子进程中运行的模块。</li>
<li><code>args</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array" class="type">&lt;Array&gt;</a> 字符串参数列表。</li>
<li><code>options</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&lt;Object&gt;</a><ul>
<li><code>cwd</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&lt;string&gt;</a> 子进程的当前工作目录。</li>
<li><code>env</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&lt;Object&gt;</a> 环境变量键值对。</li>
<li><code>execPath</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&lt;string&gt;</a> 用来创建子进程的执行路径。</li>
<li><code>execArgv</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array" class="type">&lt;Array&gt;</a> 要传给执行路径的字符串参数列表。默认为 <code>process.execArgv</code>。</li>
<li><code>silent</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&lt;boolean&gt;</a> 如果为 <code>true</code>，则子进程中的 stdin、 stdout 和 stderr 会被导流到父进程中，否则它们会继承自父进程，详见 [<code>child_process.spawn()</code>] 的 [<code>stdio</code>] 中的 <code>&apos;pipe&apos;</code> 和 <code>&apos;inherit&apos;</code> 选项。
默认: <code>false</code>。</li>
<li><code>stdio</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array" class="type">&lt;Array&gt;</a> | 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&lt;string&gt;</a> 详见 [<code>child_process.spawn()</code>] 的 [<code>stdio</code>]。
当提供了该选项，则它会覆盖 <code>silent</code>。
如果使用了数组变量，则该数组必须包含一个值为 <code>&apos;ipc&apos;</code> 的子项，否则会抛出错误。
例如 <code>[0, 1, 2, &apos;ipc&apos;]</code>。</li>
<li><code>windowsVerbatimArguments</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&lt;boolean&gt;</a> 决定在Windows系统下是否使用转义参数。 在Linux平台下会自动忽略。<strong>默认值:</strong> <code>false</code>。</li>
<li><code>uid</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&lt;number&gt;</a> 设置该进程的用户标识。（详见 <a href="http://man7.org/linux/man-pages/man2/setuid.2.html">setuid(2)</a>）</li>
<li><code>gid</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&lt;number&gt;</a> 设置该进程的组标识。（详见 <a href="http://man7.org/linux/man-pages/man2/setgid.2.html">setgid(2)</a>）</li>
</ul>
</li>
<li>返回: 
            <a href="child_process.html#child_process_class_childprocess" class="type">&lt;ChildProcess&gt;</a></li>
</ul>
<p><code>child_process.fork()</code> 方法是 [<code>child_process.spawn()</code>] 的一个特殊情况，专门用于衍生新的 Node.js 进程。
跟 [<code>child_process.spawn()</code>] 一样返回一个 [<code>ChildProcess</code>] 对象。
返回的 [<code>ChildProcess</code>] 会有一个额外的内置的通信通道，它允许消息在父进程和子进程之间来回传递。
详见 [<code>subprocess.send()</code>]。</p>
<p>衍生的 Node.js 子进程与两者之间建立的 IPC 通信信道的异常是独立于父进程的。
每个进程都有自己的内存，使用自己的 V8 实例。
由于需要额外的资源分配，因此不推荐衍生大量的 Node.js 进程。</p>
<p>默认情况下，<code>child_process.fork()</code> 会使用父进程中的 [<code>process.execPath</code>] 衍生新的 Node.js 实例。
<code>options</code> 对象中的 <code>execPath</code> 属性可以替换要使用的执行路径。</p>
<p>使用自定义的 <code>execPath</code> 启动的 Node.js 进程，会使用子进程的环境变量 <code>NODE_CHANNEL_FD</code> 中指定的文件描述符（fd）与父进程通信。</p>
<p>注意，不像 POSIX 系统回调中的 <a href="http://man7.org/linux/man-pages/man2/fork.2.html">fork(2)</a>，<code>child_process.fork()</code> 不会克隆当前进程。</p>
<p>提示: 在使用<code>child_process.fork()</code> 产生的子进程内，使用 [<code>child_process.spawn()</code>][] 会自动忽略掉其中的<code>shell</code> 配置选项并不会生效。</p>
<h3>child_process.spawn(command[, args][, options])<span><a class="mark" href="#child_process_child_process_spawn_command_args_options" id="child_process_child_process_spawn_command_args_options">#</a></span></h3>
<div class="api_metadata">
<details class="changelog"><summary>版本历史</summary>
<table>
<tbody><tr><th>版本</th><th>变更</th></tr>
<tr><td>v8.8.0</td>
<td><p>The <code>windowsHide</code> option is supported now.</p>
</td></tr>
<tr><td>v6.4.0</td>
<td><p>The <code>argv0</code> option is supported now.</p>
</td></tr>
<tr><td>v5.7.0</td>
<td><p>The <code>shell</code> option is supported now.</p>
</td></tr>
<tr><td>v0.1.90</td>
<td><p><span>新增于: v0.1.90</span></p>
</td></tr>
</tbody></table>
</details>
</div><ul>
<li><code>command</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&lt;string&gt;</a> 要运行的命令。</li>
<li><code>args</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array" class="type">&lt;Array&gt;</a> 字符串参数列表。</li>
<li><code>options</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&lt;Object&gt;</a><ul>
<li><code>cwd</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&lt;string&gt;</a> 子进程的当前工作目录。</li>
<li><code>env</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&lt;Object&gt;</a> 环境变量键值对。</li>
<li><code>argv0</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&lt;string&gt;</a> 显式地设置要发给子进程的 <code>argv[0]</code> 的值。
如果未指定，则设为 <code>command</code>。</li>
<li><code>stdio</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array" class="type">&lt;Array&gt;</a> | 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&lt;string&gt;</a> 子进程的 stdio 配置。
（详见 <a href="#child_process_options_stdio"><code>options.stdio</code></a>）</li>
<li><code>detached</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&lt;boolean&gt;</a> 准备将子进程独立于父进程运行。
具体行为取决于平台。（详见 [<code>options.detached</code>]）</li>
<li><code>uid</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&lt;number&gt;</a> 设置该进程的用户标识。（详见 <a href="http://man7.org/linux/man-pages/man2/setuid.2.html">setuid(2)</a>）</li>
<li><code>gid</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&lt;number&gt;</a> 设置该进程的组标识。（详见 <a href="http://man7.org/linux/man-pages/man2/setgid.2.html">setgid(2)</a>）</li>
<li><code>shell</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&lt;boolean&gt;</a> | 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&lt;string&gt;</a> 如果为 <code>true</code>，则在一个 shell 中运行 <code>command</code>。
在 UNIX 上使用 <code>&apos;/bin/sh&apos;</code>，在 Windows 上使用 <code>process.env.ComSpec</code>。
一个不同的 shell 可以被指定为字符串。
See [Shell Requirements][] and [Default Windows Shell][].
默认为 <code>false</code>（没有 shell）。</li>
<li><code>windowsVerbatimArguments</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&lt;boolean&gt;</a> 决定在Windows系统下是否使用转义参数。 在Linux平台下会自动忽略，当指令 <code>shell</code> 存在的时该属性将自动被设置为true。<strong>默认值:</strong> <code>false</code>。</li>
<li><code>windowsHide</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&lt;boolean&gt;</a> 是否隐藏在Windows系统下默认会弹出的子进程控制台窗口。 <strong>默认为:</strong> <code>false</code>。</li>
</ul>
</li>
<li>返回: 
            <a href="child_process.html#child_process_class_childprocess" class="type">&lt;ChildProcess&gt;</a></li>
</ul>
<p><code>child_process.spawn()</code> 方法使用给定的 <code>command</code> 和 <code>args</code> 中的命令行参数来衍生一个新进程。
如果省略 <code>args</code>，则默认为一个空数组。</p>
<p>注意：不要把未经检查的用户输入传入到该函数。
任何包括 shell 元字符的输入都可被用于触发任何命令的执行。</p>
<p>第三个参数可以用来指定额外的选项，默认如下：</p>
<pre><code class="lang-js">const defaults = {
  cwd: undefined,
  env: process.env
};
</code></pre>
<p>使用 <code>cwd</code> 来指定衍生的进程的工作目录。
如果没有给出，则默认继承当前的工作目录。</p>
<p>使用 <code>env</code> 来指定环境变量，这会在新进程中可见，默认为 [<code>process.env</code>]。</p>
<p>例子，运行 <code>ls -lh /usr</code>，捕获 <code>stdout</code>、<code>stderr</code>、以及退出码：</p>
<pre><code class="lang-js">const { spawn } = require(&apos;child_process&apos;);
const ls = spawn(&apos;ls&apos;, [&apos;-lh&apos;, &apos;/usr&apos;]);

ls.stdout.on(&apos;data&apos;, (data) =&gt; {
  console.log(`stdout: ${data}`);
});

ls.stderr.on(&apos;data&apos;, (data) =&gt; {
  console.log(`stderr: ${data}`);
});

ls.on(&apos;close&apos;, (code) =&gt; {
  console.log(`子进程退出码：${code}`);
});
</code></pre>
<p>例子，一种执行 <code>&apos;ps ax | grep ssh&apos;</code> 的方法：</p>
<pre><code class="lang-js">const { spawn } = require(&apos;child_process&apos;);
const ps = spawn(&apos;ps&apos;, [&apos;ax&apos;]);
const grep = spawn(&apos;grep&apos;, [&apos;ssh&apos;]);

ps.stdout.on(&apos;data&apos;, (data) =&gt; {
  grep.stdin.write(data);
});

ps.stderr.on(&apos;data&apos;, (data) =&gt; {
  console.log(`ps stderr: ${data}`);
});

ps.on(&apos;close&apos;, (code) =&gt; {
  if (code !== 0) {
    console.log(`ps 进程退出码：${code}`);
  }
  grep.stdin.end();
});

grep.stdout.on(&apos;data&apos;, (data) =&gt; {
  console.log(data.toString());
});

grep.stderr.on(&apos;data&apos;, (data) =&gt; {
  console.log(`grep stderr: ${data}`);
});

grep.on(&apos;close&apos;, (code) =&gt; {
  if (code !== 0) {
    console.log(`grep 进程退出码：${code}`);
  }
});
</code></pre>
<p>例子，检测失败的 <code>spawn</code>：</p>
<pre><code class="lang-js">const { spawn } = require(&apos;child_process&apos;);
const subprocess = spawn(&apos;bad_command&apos;);

subprocess.on(&apos;error&apos;, (err) =&gt; {
  console.log(&apos;启动子进程失败。&apos;);
});
</code></pre>
<p>注意：某些平台（macOS, Linux）会使用 <code>argv[0]</code> 的值作为进程的标题，而其他平台（Windows, SunOS）则使用 <code>command</code>。</p>
<p>注意，Node.js 一般会在启动时用 <code>process.execPath</code> 重写 <code>argv[0]</code>，所以 Node.js 子进程中的 <code>process.argv[0]</code> 不会匹配从父进程传给 <code>spawn</code> 的 <code>argv0</code> 参数，可以使用 <code>process.argv0</code> 属性获取它。</p>
<h4>options.detached<span><a class="mark" href="#child_process_options_detached" id="child_process_options_detached">#</a></span></h4>
<div class="api_metadata">
<span>新增于: v0.7.10</span>
</div><p>在 Windows 上，设置 <code>options.detached</code> 为 <code>true</code> 可以使子进程在父进程退出后继续运行。
子进程有自己的控制台窗口。
一旦启用一个子进程，它将不能被禁用。</p>
<p>在非 Windows 平台上，如果将 <code>options.detached</code> 设为 <code>true</code>，则子进程会成为新的进程组和会话的领导者。
注意，子进程在父进程退出后可以继续运行，不管它们是否被分离。
详见 <a href="http://man7.org/linux/man-pages/man2/setsid.2.html">setsid(2)</a>。</p>
<p>默认情况下，父进程会等待被分离的子进程退出。
为了防止父进程等待给定的 <code>subprocess</code>，可以使用 <code>subprocess.unref()</code> 方法。
这样做会导致父进程的事件循环不包含子进程的引用计数，使得父进程独立于子进程退出，除非子进程和父进程之间建立了一个 IPC 信道。</p>
<p>当使用 <code>detached</code> 选项来启动一个长期运行的进程时，该进程不会在父进程退出后保持在后台运行，除非提供了一个不连接到父进程的 <code>stdio</code> 配置。
如果父进程的 <code>stdio</code> 是继承的，则子进程会保持连接到控制终端。</p>
<p>例子，一个长期运行的进程，为了忽视父进程的终止，通过分离且忽视其父进程的 <code>stdio</code> 文件描述符来实现：</p>
<pre><code class="lang-js">const { spawn } = require(&apos;child_process&apos;);

const subprocess = spawn(process.argv[0], [&apos;child_program.js&apos;], {
  detached: true,
  stdio: &apos;ignore&apos;
});

subprocess.unref();
</code></pre>
<p>也可以将子进程的输出重定向到文件：</p>
<pre><code class="lang-js">const fs = require(&apos;fs&apos;);
const { spawn } = require(&apos;child_process&apos;);
const out = fs.openSync(&apos;./out.log&apos;, &apos;a&apos;);
const err = fs.openSync(&apos;./out.log&apos;, &apos;a&apos;);

const subprocess = spawn(&apos;prg&apos;, [], {
  detached: true,
  stdio: [ &apos;ignore&apos;, out, err ]
});

subprocess.unref();
</code></pre>
<h4>options.stdio<span><a class="mark" href="#child_process_options_stdio" id="child_process_options_stdio">#</a></span></h4>
<div class="api_metadata">
<details class="changelog"><summary>版本历史</summary>
<table>
<tbody><tr><th>版本</th><th>变更</th></tr>
<tr><td>v3.3.1</td>
<td><p>The value <code>0</code> is now accepted as a file descriptor.</p>
</td></tr>
<tr><td>v0.7.10</td>
<td><p><span>新增于: v0.7.10</span></p>
</td></tr>
</tbody></table>
</details>
</div><p><code>options.stdio</code> 选项用于配置子进程与父进程之间建立的管道。
默认情况下，子进程的 stdin、 stdout 和 stderr 会重定向到 [<code>ChildProcess</code>] 对象上相应的 [<code>subprocess.stdin</code>]、 [<code>subprocess.stdout</code>] 和 [<code>subprocess.stderr</code>] 流。
这等同于将 <code>options.stdio</code> 设为 <code>[&apos;pipe&apos;, &apos;pipe&apos;, &apos;pipe&apos;]</code>。</p>
<p>为了方便起见，<code>options.stdio</code> 可以是以下字符串之一：</p>
<ul>
<li><code>&apos;pipe&apos;</code> - 等同于 <code>[&apos;pipe&apos;, &apos;pipe&apos;, &apos;pipe&apos;]</code> （默认）</li>
<li><code>&apos;ignore&apos;</code> - 等同于 <code>[&apos;ignore&apos;, &apos;ignore&apos;, &apos;ignore&apos;]</code></li>
<li><code>&apos;inherit&apos;</code> - 等同于 <code>[process.stdin, process.stdout, process.stderr]</code> 或 <code>[0,1,2]</code></li>
</ul>
<p>另外，<code>option.stdio</code> 的值是一个每个索引都对应一个子进程 fd 的数组。
fd 的 0、1 和 2 分别对应 stdin、stdout 和 stderr。
额外的 fd 可以被指定来创建父进程和子进程之间的额外管道。
该值是以下之一：</p>
<ol>
<li><code>&apos;pipe&apos;</code> - 创建一个子进程和父进程之间的管道。
 在管道的父端以 [<code>subprocess.stdio[fd]</code>][<code>stdio</code>] 的形式作为 <code>child_process</code> 对象的一个属性暴露给父进程。
 为 fd 创建的管道 0 - 2 也可分别作为 [<code>subprocess.stdin</code>]、[<code>subprocess.stdout</code>] 和 [<code>subprocess.stderr</code>]。</li>
<li><code>&apos;ipc&apos;</code> - 创建一个用于父进程和子进程之间传递消息或文件描述符的 IPC 通道符。
 一个 [<code>ChildProcess</code>] 最多只能有一个 IPC stdio 文件描述符。
 设置该选项可启用 [<code>subprocess.send()</code>] 方法。
 如果子进程是一个 Node.js 进程，则一个已存在的 IPC 通道会在子进程中启用 [<code>process.send()</code>]、[<code>process.disconnect()</code>]、[<code>process.on(&apos;disconnect&apos;)</code>] 和 [<code>process.on(&apos;message&apos;)</code>]。</li>
<li><code>&apos;ignore&apos;</code> - 指示 Node.js 在子进程中忽略 fd。
 由于 Node.js 总是会为它衍生的进程打开 fd 0 - 2，所以设置 fd 为 <code>&apos;ignore&apos;</code> 可以使 Node.js 打开 <code>/dev/null</code> 并将它附加到子进程的 fd 上。</li>
<li>
            <a href="stream.html#stream_stream" class="type">&lt;Stream&gt;</a> 对象 - 共享一个指向子进程的 tty、文件、socket 或管道的可读或可写流。
 流的底层文件描述符在子进程中是重复对应该 <code>stdio</code> 数组的索引的 fd。
 注意，该流必须有一个底层描述符（文件流直到 <code>&apos;open&apos;</code> 事件发生才需要）。</li>
<li>正整数 - 整数值被解析为一个正在父进程中打开的文件描述符。
 它和子进程共享，类似于 
            <a href="stream.html#stream_stream" class="type">&lt;Stream&gt;</a> 是如何被共享的。</li>
<li><code>null</code>, <code>undefined</code> - 使用默认值。
 对于 stdio fd 0、1 和 2（换言之，stdin、stdout 和 stderr）而言是创建了一个管道。
 对于 fd 3 及以上而言，默认值为 <code>&apos;ignore&apos;</code>。</li>
</ol>
<p>例子：</p>
<pre><code class="lang-js">const { spawn } = require(&apos;child_process&apos;);

// 子进程使用父进程的 stdios
spawn(&apos;prg&apos;, [], { stdio: &apos;inherit&apos; });

// 衍生的子进程只共享 stderr
spawn(&apos;prg&apos;, [], { stdio: [&apos;pipe&apos;, &apos;pipe&apos;, process.stderr] });

// 打开一个额外的 fd=4，用于与程序交互
spawn(&apos;prg&apos;, [], { stdio: [&apos;pipe&apos;, null, null, null, &apos;pipe&apos;] });
</code></pre>
<p>当在父进程和子进程之间建立了一个 IPC 通道，且子进程是一个 Node.js 进程，则子进程会带着未引用的 IPC 通道（使用 <code>unref()</code>）启动，直到子进程为 [<code>process.on(&apos;disconnect&apos;)</code>] 事件或 [<code>process.on(&apos;message&apos;)</code>] 事件注册了一个事件句柄。
这使得子进程可以在进程没有通过打开的 IPC 通道保持打开的情况下正常退出。</p>
<p>详见 [<code>child_process.exec()</code>] 和 [<code>child_process.fork()</code>]。</p>
<h2>创建同步进程<span><a class="mark" href="#child_process_synchronous_process_creation" id="child_process_synchronous_process_creation">#</a></span></h2>
<p>[<code>child_process.spawnSync()</code>]、[<code>child_process.execSync()</code>] 和 [<code>child_process.execFileSync()</code>] 方法是<strong>同步的</strong>且<strong>会</strong>阻塞 Node.js 的事件循环，暂停任何额外代码的执行直到衍生的进程退出。</p>
<p>像这样的阻塞调用有利于简化普通用途的脚本任务，且启动时有利于简化应用配置的加载/处理。</p>
<h3>child_process.execFileSync(file[, args][, options])<span><a class="mark" href="#child_process_child_process_execfilesync_file_args_options" id="child_process_child_process_execfilesync_file_args_options">#</a></span></h3>
<div class="api_metadata">
<details class="changelog"><summary>版本历史</summary>
<table>
<tbody><tr><th>版本</th><th>变更</th></tr>
<tr><td>v8.8.0</td>
<td><p>The <code>windowsHide</code> option is supported now.</p>
</td></tr>
<tr><td>v8.0.0</td>
<td><p>The <code>input</code> option can now be a <code>Uint8Array</code>.</p>
</td></tr>
<tr><td>v6.2.1, v4.5.0</td>
<td><p>The <code>encoding</code> option can now explicitly be set to <code>buffer</code>.</p>
</td></tr>
<tr><td>v0.11.12</td>
<td><p><span>新增于: v0.11.12</span></p>
</td></tr>
</tbody></table>
</details>
</div><ul>
<li><code>file</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&lt;string&gt;</a> 要运行的可执行文件的名称或路径。</li>
<li><code>args</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&lt;string[]&gt;</a> 字符串参数列表。</li>
<li><code>options</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&lt;Object&gt;</a><ul>
<li><code>cwd</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&lt;string&gt;</a> 子进程的当前工作目录。</li>
<li><code>input</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&lt;string&gt;</a> | 
            <a href="buffer.html#buffer_class_buffer" class="type">&lt;Buffer&gt;</a> | 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array" class="type">&lt;Uint8Array&gt;</a> 要作为 stdin 传给衍生进程的值。<ul>
<li>提供该值会覆盖 <code>stdio[0]</code>。</li>
</ul>
</li>
<li><code>stdio</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&lt;string&gt;</a> | 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array" class="type">&lt;Array&gt;</a> 子进程的 stdio 配置。默认为 <code>&apos;pipe&apos;</code>。<ul>
<li><code>stderr</code> 默认会输出到父进程中的 stderr，除非指定了 <code>stdio</code>。</li>
</ul>
</li>
<li><code>env</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&lt;Object&gt;</a> 环境变量键值对。</li>
<li><code>uid</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&lt;number&gt;</a> 设置该进程的用户标识。（详见 <a href="http://man7.org/linux/man-pages/man2/setuid.2.html">setuid(2)</a>）</li>
<li><code>gid</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&lt;number&gt;</a> 设置该进程的组标识。（详见 <a href="http://man7.org/linux/man-pages/man2/setgid.2.html">setgid(2)</a>）</li>
<li><code>timeout</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&lt;number&gt;</a> 进程允许运行的最大时间数，以毫秒为单位。默认为 <code>undefined</code>。</li>
<li><code>killSignal</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&lt;string&gt;</a> | 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&lt;integer&gt;</a> 当衍生进程将被杀死时要使用的信号值。默认为 <code>&apos;SIGTERM&apos;</code>。</li>
<li><a href="#child_process_maxbuffer_and_unicode"><code>maxBuffer</code></a> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&lt;number&gt;</a> stdout 或 stderr 允许的最大字节数。
默认为 <code>200*1024</code>。
如果超过限制，则子进程会被终止。
See caveat at [<code>maxBuffer</code> and Unicode][].</li>
<li><code>encoding</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&lt;string&gt;</a> 用于所有 stdio 输入和输出的编码。默认为 <code>&apos;buffer&apos;</code>。</li>
<li><code>windowsHide</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&lt;boolean&gt;</a> 是否隐藏在Windows系统下默认会弹出的子进程控制台窗口。 <strong>默认为:</strong> <code>false</code>。</li>
</ul>
</li>
<li>返回: 
            <a href="buffer.html#buffer_class_buffer" class="type">&lt;Buffer&gt;</a> | 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&lt;string&gt;</a> 该命令的 stdout。</li>
</ul>
<p><code>child_process.execFileSync()</code> 方法与 [<code>child_process.execFile()</code>] 基本相同，除了该方法直到子进程完全关闭后才返回。
当遇到超时且发送了 <code>killSignal</code> 时，则该方法直到进程完全退出后才返回结果。</p>
<p>注意，如果子进程拦截并处理了 <code>SIGTERM</code> 信号且没有退出，则父进程会一直等待直到子进程退出。</p>
<p>如果进程超时，或有一个非零的退出码，则该方法会抛出一个 [<code>Error</code>]，这个错误对象包含了底层 [<code>child_process.spawnSync()</code>] 的完整结果。</p>
<h3>child_process.execSync(command[, options])<span><a class="mark" href="#child_process_child_process_execsync_command_options" id="child_process_child_process_execsync_command_options">#</a></span></h3>
<div class="api_metadata">
<details class="changelog"><summary>版本历史</summary>
<table>
<tbody><tr><th>版本</th><th>变更</th></tr>
<tr><td>v8.8.0</td>
<td><p>The <code>windowsHide</code> option is supported now.</p>
</td></tr>
<tr><td>v8.0.0</td>
<td><p>The <code>input</code> option can now be a <code>Uint8Array</code>.</p>
</td></tr>
<tr><td>v0.11.12</td>
<td><p><span>新增于: v0.11.12</span></p>
</td></tr>
</tbody></table>
</details>
</div><ul>
<li><code>command</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&lt;string&gt;</a> 要运行的命令。</li>
<li><code>options</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&lt;Object&gt;</a><ul>
<li><code>cwd</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&lt;string&gt;</a> 子进程的当前工作目录。</li>
<li><code>input</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&lt;string&gt;</a> | 
            <a href="buffer.html#buffer_class_buffer" class="type">&lt;Buffer&gt;</a> | 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array" class="type">&lt;Uint8Array&gt;</a>} 要作为 stdin 传给衍生进程的值。<ul>
<li>提供该值会覆盖 <code>stdio[0]</code>。</li>
</ul>
</li>
<li><code>stdio</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&lt;string&gt;</a> | 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array" class="type">&lt;Array&gt;</a> 子进程的 stdio 配置。默认为 <code>&apos;pipe&apos;</code>。<ul>
<li><code>stderr</code> 默认会输出到父进程中的 stderr，除非指定了 <code>stdio</code>。</li>
</ul>
</li>
<li><code>env</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&lt;Object&gt;</a> 环境变量键值对。</li>
<li><code>shell</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&lt;string&gt;</a> 用于执行命令的 shell。
在 UNIX 上默认为 <code>&apos;/bin/sh&apos;</code>，在 Windows 上默认为 <code>process.env.ComSpec</code>。
See [Shell Requirements][] and [Default Windows Shell][].</li>
<li><code>uid</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&lt;number&gt;</a> 设置该进程的用户标识。（详见 <a href="http://man7.org/linux/man-pages/man2/setuid.2.html">setuid(2)</a>）</li>
<li><code>gid</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&lt;number&gt;</a> 设置该进程的组标识。（详见 <a href="http://man7.org/linux/man-pages/man2/setgid.2.html">setgid(2)</a>）</li>
<li><code>timeout</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&lt;number&gt;</a> 进程允许运行的最大时间数，以毫秒为单位。默认为 <code>undefined</code>。</li>
<li><code>killSignal</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&lt;string&gt;</a> | 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&lt;integer&gt;</a> 当衍生进程将被杀死时要使用的信号值。默认为 <code>&apos;SIGTERM&apos;</code>。</li>
<li><a href="#child_process_maxbuffer_and_unicode"><code>maxBuffer</code></a> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&lt;number&gt;</a> stdout 或 stderr 允许的最大字节数。
默认为 <code>200*1024</code>。
如果超过限制，则子进程会被终止。
See caveat at [<code>maxBuffer</code> and Unicode][].</li>
<li><code>encoding</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&lt;string&gt;</a> 用于所有 stdio 输入和输出的编码。默认为 <code>&apos;buffer&apos;</code>。</li>
<li><code>windowsHide</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&lt;boolean&gt;</a> 是否隐藏在Windows系统下默认会弹出的子进程控制台窗口。 <strong>默认为:</strong> <code>false</code>。</li>
</ul>
</li>
<li>返回: 
            <a href="buffer.html#buffer_class_buffer" class="type">&lt;Buffer&gt;</a> | 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&lt;string&gt;</a> 该命令的 stdout。</li>
</ul>
<p><code>child_process.execSync()</code> 方法与 [<code>child_process.exec()</code>] 基本相同，除了该方法直到子进程完全关闭后才返回。
当遇到超时且发送了 <code>killSignal</code> 时，则该方法直到进程完全退出后才返回结果。
注意，如果子进程拦截并处理了 <code>SIGTERM</code> 信号且没有退出，则父进程会一直等待直到子进程退出。</p>
<p>如果进程超时，或有一个非零的退出码，则该方法会抛出错误。
[<code>Error</code>] 对象会包含从 [<code>child_process.spawnSync()</code>] 返回的整个结果。</p>
<p>注意：不要把未经检查的用户输入传入到该函数。
任何包括 shell 元字符的输入都可被用于触发任何命令的执行。</p>
<h3>child_process.spawnSync(command[, args][, options])<span><a class="mark" href="#child_process_child_process_spawnsync_command_args_options" id="child_process_child_process_spawnsync_command_args_options">#</a></span></h3>
<div class="api_metadata">
<details class="changelog"><summary>版本历史</summary>
<table>
<tbody><tr><th>版本</th><th>变更</th></tr>
<tr><td>v8.8.0</td>
<td><p>The <code>windowsHide</code> option is supported now.</p>
</td></tr>
<tr><td>v8.0.0</td>
<td><p>The <code>input</code> option can now be a <code>Uint8Array</code>.</p>
</td></tr>
<tr><td>v6.2.1, v4.5.0</td>
<td><p>The <code>encoding</code> option can now explicitly be set to <code>buffer</code>.</p>
</td></tr>
<tr><td>v5.7.0</td>
<td><p>The <code>shell</code> option is supported now.</p>
</td></tr>
<tr><td>v0.11.12</td>
<td><p><span>新增于: v0.11.12</span></p>
</td></tr>
</tbody></table>
</details>
</div><ul>
<li><code>command</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&lt;string&gt;</a> 要运行的命令。</li>
<li><code>args</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array" class="type">&lt;Array&gt;</a> 字符串参数列表。</li>
<li><code>options</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&lt;Object&gt;</a><ul>
<li><code>cwd</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&lt;string&gt;</a> 子进程的当前工作目录。</li>
<li><code>input</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&lt;string&gt;</a> | 
            <a href="buffer.html#buffer_class_buffer" class="type">&lt;Buffer&gt;</a> | 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array" class="type">&lt;Uint8Array&gt;</a> 要作为 stdin 传给衍生进程的值。<ul>
<li>提供该值会覆盖 <code>stdio[0]</code></li>
</ul>
</li>
<li><code>stdio</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&lt;string&gt;</a> | 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array" class="type">&lt;Array&gt;</a> 子进程的 stdio 配置。</li>
<li><code>env</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&lt;Object&gt;</a> 环境变量键值对。</li>
<li><code>uid</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&lt;number&gt;</a> 设置该进程的用户标识。（详见 <a href="http://man7.org/linux/man-pages/man2/setuid.2.html">setuid(2)</a>）</li>
<li><code>gid</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&lt;number&gt;</a> 设置该进程的组标识。（详见 <a href="http://man7.org/linux/man-pages/man2/setgid.2.html">setgid(2)</a>）</li>
<li><code>timeout</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&lt;number&gt;</a> 进程允许运行的最大时间数，以毫秒为单位。默认为 <code>undefined</code>。</li>
<li><code>killSignal</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&lt;string&gt;</a> | 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&lt;integer&gt;</a> 当衍生进程将被杀死时要使用的信号值。默认为 <code>&apos;SIGTERM&apos;</code>。</li>
<li><a href="#child_process_maxbuffer_and_unicode"><code>maxBuffer</code></a> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&lt;number&gt;</a> stdout 或 stderr 允许的最大字节数。
默认为 <code>200*1024</code>。
如果超过限制，则子进程会被终止。
See caveat at [<code>maxBuffer</code> and Unicode][].</li>
<li><code>encoding</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&lt;string&gt;</a> 用于所有 stdio 输入和输出的编码。默认为 <code>&apos;buffer&apos;</code>。</li>
<li><code>shell</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&lt;boolean&gt;</a> | 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&lt;string&gt;</a> 如果为 <code>true</code>，则在一个 shell 中运行 <code>command</code>。
在 UNIX 上使用 <code>&apos;/bin/sh&apos;</code>，在 Windows 上使用 <code>process.env.ComSpec</code>。
一个不同的 shell 可以被指定为字符串。<pre><code>查看 [Shell Requirements][] 和 [Default Windows Shell][].
</code></pre>默认为 <code>false</code>（没有 shell）。</li>
<li><code>windowsVerbatimArguments</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&lt;boolean&gt;</a> 决定在Windows系统下是否使用转义参数。 在Linux平台下会自动忽略，当指令 <code>shell</code> 存在的时该属性将自动被设置为true。<strong>默认值:</strong> <code>false</code>。</li>
<li><code>windowsHide</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&lt;boolean&gt;</a> 是否隐藏在Windows系统下默认会弹出的子进程控制台窗口。 <strong>默认为:</strong> <code>false</code>。</li>
</ul>
</li>
<li>返回: 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&lt;Object&gt;</a><ul>
<li><code>pid</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&lt;number&gt;</a> 子进程的 pid。</li>
<li><code>output</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array" class="type">&lt;Array&gt;</a> stdio 输出返回的结果数组。</li>
<li><code>stdout</code> 
            <a href="buffer.html#buffer_class_buffer" class="type">&lt;Buffer&gt;</a> | 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&lt;string&gt;</a> <code>output[1]</code> 的内容。</li>
<li><code>stderr</code> 
            <a href="buffer.html#buffer_class_buffer" class="type">&lt;Buffer&gt;</a> | 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&lt;string&gt;</a> <code>output[2]</code> 的内容。</li>
<li><code>status</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&lt;number&gt;</a> 子进程的退出码。</li>
<li><code>signal</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&lt;string&gt;</a> 用于杀死子进程的信号。</li>
<li><code>error</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&lt;Error&gt;</a> 如果子进程失败或超时产生的错误对象。</li>
</ul>
</li>
</ul>
<p><code>child_process.spawnSync()</code> 方法与 [<code>child_process.spawn()</code>] 基本相同，除了该方法直到子进程完全关闭后才返回。
当遇到超时且发送了 <code>killSignal</code> 时，则该方法直到进程完全退出后才返回结果。
注意，如果子进程拦截并处理了 <code>SIGTERM</code> 信号且没有退出，则父进程会一直等待直到子进程退出。</p>
<p>注意：不要把未经检查的用户输入传入到该函数。
任何包括 shell 元字符的输入都可被用于触发任何命令的执行。</p>
<h2>ChildProcess 类<span><a class="mark" href="#child_process_class_childprocess" id="child_process_class_childprocess">#</a></span></h2>
<div class="api_metadata">
<span>新增于: v2.2.0</span>
</div><p><code>ChildProcess</code> 类的实例是 [<code>EventEmitter</code>]，代表衍生的子进程。</p>
<p><code>ChildProcess</code> 的实例不被直接创建。
而是，使用 [<code>child_process.spawn()</code>]、[<code>child_process.exec()</code>]、[<code>child_process.execFile()</code>] 或 [<code>child_process.fork()</code>] 方法创建 <code>ChildProcess</code> 实例。</p>
<h3>&apos;close&apos; 事件<span><a class="mark" href="#child_process_event_close" id="child_process_event_close">#</a></span></h3>
<div class="api_metadata">
<span>新增于: v0.7.7</span>
</div><ul>
<li><code>code</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&lt;number&gt;</a> 如果子进程退出自身，则该值是退出码。</li>
<li><code>signal</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&lt;string&gt;</a> 子进程被终止时的信号。</li>
</ul>
<p>当子进程的 stdio 流被关闭时会触发 <code>&apos;close&apos;</code> 事件。
这与 [<code>&apos;exit&apos;</code>] 事件不同，因为多个进程可能共享同一 stdio 流。</p>
<h3>&apos;disconnect&apos; 事件<span><a class="mark" href="#child_process_event_disconnect" id="child_process_event_disconnect">#</a></span></h3>
<div class="api_metadata">
<span>新增于: v0.7.2</span>
</div><p>在父进程中调用 [<code>subprocess.disconnect()</code>] 或在子进程中调用 [<code>process.disconnect()</code>] 后会触发 <code>&apos;disconnect&apos;</code> 事件。
断开后就不能再发送或接收信息，且 [<code>subprocess.connected</code>] 属性会被设为 <code>false</code>。</p>
<h3>&apos;error&apos; 事件<span><a class="mark" href="#child_process_event_error" id="child_process_event_error">#</a></span></h3>
<div class="signature"><ul>
<li><code>err</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error" class="type">&lt;Error&gt;</a> 错误对象。</li>
</ul>
</div><p>每当出现以下情况时触发 <code>&apos;error&apos;</code> 事件：</p>
<ol>
<li><p>进程无法被衍生；</p>
</li>
<li><p>进程无法被杀死；</p>
</li>
<li><p>向子进程发送信息失败。</p>
</li>
</ol>
<p>注意，在错误发生后，<code>&apos;exit&apos;</code> 事件可能会也可能不会触发。
当同时监听了 <code>&apos;exit&apos;</code> 和 <code>&apos;error&apos;</code> 事件，谨防处理函数被多次调用。</p>
<p>详见 [<code>subprocess.kill()</code>] 和 [<code>subprocess.send()</code>]。</p>
<h3>&apos;exit&apos; 事件<span><a class="mark" href="#child_process_event_exit" id="child_process_event_exit">#</a></span></h3>
<div class="api_metadata">
<span>新增于: v0.1.90</span>
</div><ul>
<li><code>code</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&lt;number&gt;</a> 如果子进程退出自身，则该值是退出码。</li>
<li><code>signal</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&lt;string&gt;</a> 子进程被终止时的信号。</li>
</ul>
<p>子进程结束后会触发 <code>&apos;exit&apos;</code> 事件。
如果进程退出了，则 <code>code</code> 是进程的最终退出码，否则为 <code>null</code>。
如果进程是收到的信号而终止的，则 <code>signal</code> 是信号的字符串名称，否则为 <code>null</code>。
这两个总有一个是非空的。</p>
<p>注意，当 <code>&apos;exit&apos;</code> 事件被触发时，子进程的 stdio 流可能依然是打开的。</p>
<p>另外，还要注意，Node.js 建立了 <code>SIGINT</code> 和 <code>SIGTERM</code> 的信号处理程序，且 Node.js 进程收到这些信号也不会立即终止。
相反，Node.js 会执行一系列的清理操作后重新引发处理信号。</p>
<p>详见 <a href="http://man7.org/linux/man-pages/man2/waitpid.2.html">waitpid(2)</a>。</p>
<h3>&apos;message&apos; 事件<span><a class="mark" href="#child_process_event_message" id="child_process_event_message">#</a></span></h3>
<div class="api_metadata">
<span>新增于: v0.5.9</span>
</div><ul>
<li><code>message</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&lt;Object&gt;</a> 一个已解析的 JSON 对象或原始值。</li>
<li><code>sendHandle</code> 
            <a href="net.html#net_server_listen_handle_backlog_callback" class="type">&lt;Handle&gt;</a> 一个 [<code>net.Socket</code>] 或 [<code>net.Server</code>] 对象 或 <code>undefined</code>。</li>
</ul>
<p>当一个子进程使用 [<code>process.send()</code>] 发送消息时会触发 <code>&apos;message&apos;</code> 事件。</p>
<p><em>注意</em>: 消息通过序列化和解析传递，结果就是消息可能跟开始发送的不完全一样。</p>
<p><a name="child_process_child_channel"></a></p>
<h3>subprocess.channel<span><a class="mark" href="#child_process_subprocess_channel" id="child_process_subprocess_channel">#</a></span></h3>
<div class="api_metadata">
<span>新增于: v7.1.0</span>
</div><ul>
<li>
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&lt;Object&gt;</a> 代表子进程的IPC通道的管道。</li>
</ul>
<p><code>subprocess.channel</code> 属性是当前子进程的 IPC 通道的引用。如果当前没有 IPC 通道，则该属性为 <code>undefined</code>。</p>
<p><a name="child_process_child_connected"></a></p>
<h3>subprocess.connected<span><a class="mark" href="#child_process_subprocess_connected" id="child_process_subprocess_connected">#</a></span></h3>
<div class="api_metadata">
<span>新增于: v0.7.2</span>
</div><ul>
<li>
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&lt;boolean&gt;</a> 调用 <code>subprocess.disconnect()</code> 后会被设为 <code>false</code></li>
</ul>
<p><code>subprocess.connected</code> 属性表明是否仍可以从一个子进程发送和接收消息。
当 <code>subprocess.connected</code> 为 <code>false</code> 时，则不能再发送或接收的消息。</p>
<p><a name="child_process_child_disconnect"></a></p>
<h3>subprocess.disconnect()<span><a class="mark" href="#child_process_subprocess_disconnect" id="child_process_subprocess_disconnect">#</a></span></h3>
<div class="api_metadata">
<span>新增于: v0.7.2</span>
</div><p>关闭父进程与子进程之间的 IPC 通道，一旦没有其他的连接使其保持活跃，则允许子进程正常退出。
调用该方法后，父进程和子进程上各自的 <code>subprocess.connected</code> 和 <code>process.connected</code> 属性都会被设为 <code>false</code>，且进程之间不能再传递消息。</p>
<p>当正在接收的进程中没有消息时，就会触发 <code>&apos;disconnect&apos;</code> 事件。
这经常在调用 <code>subprocess.disconnect()</code> 后立即被触发。</p>
<p>注意，当子进程是一个 Node.js 实例时（例如通过 [<code>child_process.fork()</code>] 衍生的），可以在子进程内调用 <code>process.disconnect()</code> 方法来关闭 IPC 通道。</p>
<p><a name="child_process_child_kill_signal"></a></p>
<h3>subprocess.kill([signal])<span><a class="mark" href="#child_process_subprocess_kill_signal" id="child_process_subprocess_kill_signal">#</a></span></h3>
<div class="api_metadata">
<span>新增于: v0.1.90</span>
</div><ul>
<li><code>signal</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type" class="type">&lt;string&gt;</a></li>
</ul>
<p><code>subprocess.kill()</code> 方法向子进程发送一个信号。
如果没有给定参数，则进程会发送 <code>&apos;SIGTERM&apos;</code> 信号。
查看 <a href="http://man7.org/linux/man-pages/man7/signal.7.html">signal(7)</a> 了解可用的信号列表。</p>
<pre><code class="lang-js">const { spawn } = require(&apos;child_process&apos;);
const grep = spawn(&apos;grep&apos;, [&apos;ssh&apos;]);

grep.on(&apos;close&apos;, (code, signal) =&gt; {
  console.log(`子进程收到信号 ${signal} 而终止`);
});

// 发送 SIGHUP 到进程
grep.kill(&apos;SIGHUP&apos;);
</code></pre>
<p>如果信号没有被送达，[<code>ChildProcess</code>] 对象可能会触发一个 [<code>&apos;error&apos;</code>] 事件。
向一个已经退出的子进程发送信号不是一个错误，但可能有无法预知的后果。
特别是，如果进程的 PID 已经重新分配给其他进程，则信号会被发送到该进程，从而可能有意想不到的结果。</p>
<p>注意，当函数被调用 <code>kill</code> 时，已发送到子进程的信号可能没有实际终止该进程。</p>
<p>详见 <a href="http://man7.org/linux/man-pages/man2/kill.2.html">kill(2)</a>。</p>
<p>注意：在 Linux 上，当试图杀死父进程时，子进程的子进程不会被终止。
这有可能发生在当在一个 shell 中运行一个新进程时，或使用 <code>ChildProcess</code> 中的 <code>shell</code> 选项时，例如：</p>
<pre><code class="lang-js">&apos;use strict&apos;;
const { spawn } = require(&apos;child_process&apos;);

const subprocess = spawn(
  &apos;sh&apos;,
  [
    &apos;-c&apos;,
    `node -e &quot;setInterval(() =&gt; {
      console.log(process.pid, &apos;is alive&apos;)
    }, 500);&quot;`
  ], {
    stdio: [&apos;inherit&apos;, &apos;inherit&apos;, &apos;inherit&apos;]
  }
);

setTimeout(() =&gt; {
  subprocess.kill(); // 不会终止 shell 中的 node 进程
}, 2000);
</code></pre>
<h3>subprocess.killed<span><a class="mark" href="#child_process_subprocess_killed" id="child_process_subprocess_killed">#</a></span></h3>
<div class="api_metadata">
<span>新增于: v0.5.10</span>
</div><ul>
<li>
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&lt;boolean&gt;</a> 当 <code>subprocess.kill()</code> 已成功发送信号给子进程后会被设置为 <code>true</code>。</li>
</ul>
<p><code>subprocess.killed</code> 属性表明该子进程是否已成功接收到 <code>subprocess.kill()</code> 的信号。
该属性不代表子进程是否已被终止。</p>
<p><a name="child_process_child_pid"></a></p>
<h3>subprocess.pid<span><a class="mark" href="#child_process_subprocess_pid" id="child_process_subprocess_pid">#</a></span></h3>
<div class="api_metadata">
<span>新增于: v0.1.90</span>
</div><ul>
<li>
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type" class="type">&lt;number&gt;</a> 整数</li>
</ul>
<p>返回子进程的进程标识（PID）。</p>
<p>例子：</p>
<pre><code class="lang-js">const { spawn } = require(&apos;child_process&apos;);
const grep = spawn(&apos;grep&apos;, [&apos;ssh&apos;]);

console.log(`衍生的子进程的 pid：${grep.pid}`);
grep.stdin.end();
</code></pre>
<p><a name="child_process_child_send_message_sendhandle_options_callback"></a></p>
<h3>subprocess.send(message[, sendHandle[, options]][, callback])<span><a class="mark" href="#child_process_subprocess_send_message_sendhandle_options_callback" id="child_process_subprocess_send_message_sendhandle_options_callback">#</a></span></h3>
<div class="api_metadata">
<details class="changelog"><summary>版本历史</summary>
<table>
<tbody><tr><th>版本</th><th>变更</th></tr>
<tr><td>v5.8.0</td>
<td><p>The <code>options</code> parameter, and the <code>keepOpen</code> option in particular, is supported now.</p>
</td></tr>
<tr><td>v5.0.0</td>
<td><p>This method returns a boolean for flow control now.</p>
</td></tr>
<tr><td>v4.0.0</td>
<td><p>The <code>callback</code> parameter is supported now.</p>
</td></tr>
<tr><td>v0.5.9</td>
<td><p><span>新增于: v0.5.9</span></p>
</td></tr>
</tbody></table>
</details>
</div><ul>
<li><code>message</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&lt;Object&gt;</a></li>
<li><code>sendHandle</code> 
            <a href="net.html#net_server_listen_handle_backlog_callback" class="type">&lt;Handle&gt;</a></li>
<li><code>options</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object" class="type">&lt;Object&gt;</a></li>
<li><code>callback</code> 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function" class="type">&lt;Function&gt;</a></li>
<li>返回: 
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type" class="type">&lt;boolean&gt;</a></li>
</ul>
<p>当父进程和子进程之间建立了一个 IPC 通道时（例如，使用 [<code>child_process.fork()</code>]），<code>subprocess.send()</code> 方法可用于发送消息到子进程。
当子进程是一个 Node.js 实例时，消息可以通过 [<code>process.on(&apos;message&apos;)</code>] 事件接收。</p>
<p><em>注意</em>: 消息通过序列化和解析进行传递，结果就是消息可能跟开始发送的不完全一样。</p>
<p>例子，父进程脚本如下：</p>
<pre><code class="lang-js">const cp = require(&apos;child_process&apos;);
const n = cp.fork(`${__dirname}/sub.js`);

n.on(&apos;message&apos;, (m) =&gt; {
  console.log(&apos;父进程收到消息：&apos;, m);
});

// Causes the child to print: CHILD got message: { hello: &apos;world&apos; }
n.send({ hello: &apos;world&apos; });
</code></pre>
<p>然后是子进程脚本，<code>&apos;sub.js&apos;</code> 可能看上去像这样：</p>
<pre><code class="lang-js">process.on(&apos;message&apos;, (m) =&gt; {
  console.log(&apos;子进程收到消息：&apos;, m);
});

// Causes the parent to print: PARENT got message: { foo: &apos;bar&apos;, baz: null }
process.send({ foo: &apos;bar&apos;, baz: NaN });
</code></pre>
<p>Node.js 中的子进程有一个自己的 [<code>process.send()</code>] 方法，允许子进程发送消息回父进程。</p>
<p>当发送一个 <code>{cmd: &apos;NODE_foo&apos;}</code> 消息时，是一个特例。
<code>cmd</code> 属性中包含 <code>NODE_</code> 前缀的消息是预留给 Node.js 核心代码内部使用的，不会触发子进程的 [<code>process.on(&apos;message&apos;)</code>] 事件。
而是，这种消息可使用 <code>process.on(&apos;internalMessage&apos;)</code> 事件触发，且被 Node.js 内部消费。
应用程序应避免使用这种消息或监听 <code>&apos;internalMessage&apos;</code> 事件。</p>
<p>可选的 <code>sendHandle</code> 参数可能被传给 <code>subprocess.send()</code>，它用于传入一个 TCP 服务器或 socket 对象给子进程。
子进程会接收对象作为第二个参数，并传给注册在 [<code>process.on(&apos;message&apos;)</code>] 事件上的回调函数。
socket 上接收或缓冲的任何数据不会被发送给子进程。</p>
<p><code>options</code> 参数，如果存在的话，是一个用于处理发送数据参数对象。<code>options</code> 支持以下属性：</p>
<ul>
<li><code>keepOpen</code> - 一个 Boolean 值，当传入 <code>net.Socket</code> 实例时可用。
当为 <code>true</code> 时，socket 在发送进程中保持打开。
默认为 <code>false</code>。</li>
</ul>
<p>可选的 <code>callback</code> 是一个函数，它在消息发送之后、子进程收到消息之前被调用。
该函数被调用时只有一个参数：成功时是 <code>null</code>，失败时是一个 [<code>Error</code>] 对象。</p>
<p>如果没有提供 <code>callback</code> 函数，且消息没被发送，则一个 <code>&apos;error&apos;</code> 事件将被 [<code>ChildProcess</code>] 对象触发。
这是有可能发生的，例如当子进程已经退出时。</p>
<p>如果通道已关闭，或当未发送的消息的积压超过阈值使其无法发送更多时，<code>subprocess.send()</code> 会返回 <code>false</code>。
除此以外，该方法返回 <code>true</code>。
<code>callback</code> 函数可用于实现流量控制。</p>
<h4>例子：发送一个 server 对象<span><a class="mark" href="#child_process_example_sending_a_server_object" id="child_process_example_sending_a_server_object">#</a></span></h4>
<p><code>sendHandle</code> 参数可用于将一个 TCP server 对象句柄传给子进程，如下所示：</p>
<pre><code class="lang-js">const subprocess = require(&apos;child_process&apos;).fork(&apos;subprocess.js&apos;);

// 开启 server 对象，并发送该句柄。
const server = require(&apos;net&apos;).createServer();
server.on(&apos;connection&apos;, (socket) =&gt; {
  socket.end(&apos;被父进程处理&apos;);
});
server.listen(1337, () =&gt; {
  subprocess.send(&apos;server&apos;, server);
});
</code></pre>
<p>子进程接收 server 对象如下：</p>
<pre><code class="lang-js">process.on(&apos;message&apos;, (m, server) =&gt; {
  if (m === &apos;server&apos;) {
    server.on(&apos;connection&apos;, (socket) =&gt; {
      socket.end(&apos;被子进程处理&apos;);
    });
  }
});
</code></pre>
<p>当服务器在父进程和子进程之间是共享的，则一些连接可被父进程处理，另一些可被子进程处理。</p>
<p>上面的例子使用了一个 <code>net</code> 模块创建的服务器，而 <code>dgram</code> 模块的服务器使用完全相同的工作流程，但它监听一个 <code>&apos;message&apos;</code> 事件而不是 <code>&apos;connection&apos;</code> 事件，且使用 <code>server.bind</code> 而不是 <code>server.listen()</code>。
目前仅 UNIX 平台支持这一点。</p>
<h4>例子：发送一个 socket 对象<span><a class="mark" href="#child_process_example_sending_a_socket_object" id="child_process_example_sending_a_socket_object">#</a></span></h4>
<p>同样，<code>sendHandle</code> 参数可用于将一个 socket 句柄传给子进程。
以下例子衍生了两个子进程，分别用于处理 &quot;normal&quot; 连接或优先处理 &quot;special&quot; 连接：</p>
<pre><code class="lang-js">const { fork } = require(&apos;child_process&apos;);
const normal = fork(&apos;subprocess.js&apos;, [&apos;normal&apos;]);
const special = fork(&apos;subprocess.js&apos;, [&apos;special&apos;]);

// 开启 server，并发送 socket 给子进程。
// 使用 `pauseOnConnect` 防止 socket 在被发送到子进程之前被读取。
const server = require(&apos;net&apos;).createServer({ pauseOnConnect: true });
server.on(&apos;connection&apos;, (socket) =&gt; {

  // 特殊优先级
  if (socket.remoteAddress === &apos;74.125.127.100&apos;) {
    special.send(&apos;socket&apos;, socket);
    return;
  }
  // 普通优先级
  normal.send(&apos;socket&apos;, socket);
});
server.listen(1337);
</code></pre>
<p><code>subprocess.js</code> 会接收到一个 socket 句柄，并作为第二个参数传给事件回调函数：</p>
<pre><code class="lang-js">process.on(&apos;message&apos;, (m, socket) =&gt; {
  if (m === &apos;socket&apos;) {
    socket.end(`请求被 ${process.argv[2]} 优先级处理`);
  }
});
process.on(&apos;message&apos;, (m, socket) =&gt; {
  if (m === &apos;socket&apos;) {
    if (socket) {
      // 检查客户端 socket 是否存在。
      // socket 在被发送与被子进程接收这段时间内可被关闭。
      socket.end(`请求被 ${process.argv[2]} 优先级处理`);
    }
  }
});
</code></pre>
<p>一旦一个 socket 已被传给了子进程，则父进程不再能够跟踪 socket 何时被销毁。
为了表明这个，<code>.connections</code> 属性会变成 <code>null</code>。
当发生这种情况时，建议不要使用 <code>.maxConnections</code>。</p>
<p>建议在子进程中的任何 <code>message</code> 处理程序都需要验证 <code>socket</code> 是否存在，因为连接可能会在它在发送给子进程的这段时间内被关闭。</p>
<p>注意，该函数内部使用 [<code>JSON.stringify()</code>] 序列化 <code>message</code>。</p>
<p><a name="child_process_child_stderr"></a></p>
<h3>subprocess.stderr<span><a class="mark" href="#child_process_subprocess_stderr" id="child_process_subprocess_stderr">#</a></span></h3>
<div class="api_metadata">
<span>新增于: v0.1.90</span>
</div><ul>
<li>
            <a href="stream.html#stream_class_stream_readable" class="type">&lt;stream.Readable&gt;</a></li>
</ul>
<p>一个代表子进程的 <code>stderr</code> 的可读流。</p>
<p>如果子进程被衍生时 <code>stdio[2]</code> 被设为任何不是 <code>&apos;pipe&apos;</code> 的值，则这会是 <code>null</code>。</p>
<p><code>subprocess.stderr</code> 是 <code>subprocess.stdio[2]</code> 的一个别名。
这两个属性指向相同的值。</p>
<p><a name="child_process_child_stdin"></a></p>
<h3>subprocess.stdin<span><a class="mark" href="#child_process_subprocess_stdin" id="child_process_subprocess_stdin">#</a></span></h3>
<div class="api_metadata">
<span>新增于: v0.1.90</span>
</div><ul>
<li>
            <a href="stream.html#stream_class_stream_writable" class="type">&lt;stream.Writable&gt;</a></li>
</ul>
<p>一个代表子进程的 <code>stdin</code> 的可写流。</p>
<p>注意，如果一个子进程正在等待读取所有的输入，则子进程不会继续直到流已通过 <code>end()</code> 关闭。</p>
<p>如果子进程被衍生时 <code>stdio[0]</code> 被设为任何不是 <code>&apos;pipe&apos;</code> 的值，则这会是 <code>null</code>。</p>
<p><code>subprocess.stdin</code> 是 <code>subprocess.stdio[0]</code> 的一个别名。
这两个属性指向相同的值。</p>
<p><a name="child_process_child_stdio"></a></p>
<h3>subprocess.stdio<span><a class="mark" href="#child_process_subprocess_stdio" id="child_process_subprocess_stdio">#</a></span></h3>
<div class="api_metadata">
<span>新增于: v0.7.10</span>
</div><ul>
<li>
            <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array" class="type">&lt;Array&gt;</a></li>
</ul>
<p>一个到子进程的管道的稀疏数组，对应着传给 [<code>child_process.spawn()</code>] 的选项中值被设为 <code>&apos;pipe&apos;</code> 的 [<code>stdio</code>]。
注意，<code>subprocess.stdio[0]</code>、<code>subprocess.stdio[1]</code> 和 <code>subprocess.stdio[2]</code> 分别可用作 <code>subprocess.stdin</code>、 <code>subprocess.stdout</code> 和 <code>subprocess.stderr</code>。</p>
<p>在下面的例子中，只有子进程的 fd <code>1</code>（stdout）被配置为一个管道，所以只有父进程的 <code>subprocess.stdio[1]</code> 是一个流，数组中的其他值都是 <code>null</code>。</p>
<pre><code class="lang-js">const assert = require(&apos;assert&apos;);
const fs = require(&apos;fs&apos;);
const child_process = require(&apos;child_process&apos;);

const subprocess = child_process.spawn(&apos;ls&apos;, {
  stdio: [
    0, // 使用父进程的 stdin 用于子进程
    &apos;pipe&apos;, // 把子进程的 stdout 通过管道传到父进程 
    fs.openSync(&apos;err.out&apos;, &apos;w&apos;) // 把子进程的 stderr 指向一个文件
  ]
});

assert.strictEqual(subprocess.stdio[0], null);
assert.strictEqual(subprocess.stdio[0], subprocess.stdin);

assert(subprocess.stdout);
assert.strictEqual(subprocess.stdio[1], subprocess.stdout);

assert.strictEqual(subprocess.stdio[2], null);
assert.strictEqual(subprocess.stdio[2], subprocess.stderr);
</code></pre>
<p><a name="child_process_child_stdout"></a></p>
<h3>subprocess.stdout<span><a class="mark" href="#child_process_subprocess_stdout" id="child_process_subprocess_stdout">#</a></span></h3>
<div class="api_metadata">
<span>新增于: v0.1.90</span>
</div><ul>
<li>
            <a href="stream.html#stream_class_stream_readable" class="type">&lt;stream.Readable&gt;</a></li>
</ul>
<p>一个代表子进程的 <code>stdout</code> 的可读流。</p>
<p>如果子进程被衍生时 <code>stdio[1]</code> 被设为任何不是 <code>&apos;pipe&apos;</code> 的值，则这会是 <code>null</code>。</p>
<p><code>subprocess.stdout</code> 是 <code>subprocess.stdio[1]</code> 的一个别名。
这两个属性指向相同的值。</p>
<h2><code>maxBuffer</code> 与 Unicode<span><a class="mark" href="#child_process_maxbuffer_and_unicode" id="child_process_maxbuffer_and_unicode">#</a></span></h2>
<p><code>maxBuffer</code> 选项指定了 <code>stdout</code> 或 <code>stderr</code> 上允许的字节数的最大值。
如果超过这个值，则子进程会被终止。
这会影响包含多字节字符编码的输出，如 UTF-8 或 UTF-16。
例如，<code>console.log(&apos;中文测试&apos;)</code> 会发送 13 个 UTF-8 编码的字节到 <code>stdout</code>，尽管只有 4 个字符。</p>
<h2>Shell 的要求<span><a class="mark" href="#child_process_shell_requirements" id="child_process_shell_requirements">#</a></span></h2>
<p>Shell应该知道UNIX中的<code>-c</code>开关或者Window上的<code>/d /s /c</code>。在Windows上，命令行解析应该兼容<code>&apos;cmd.exe&apos;</code>。</p>
<h2>Windows 默认的 Shell<span><a class="mark" href="#child_process_default_windows_shell" id="child_process_default_windows_shell">#</a></span></h2>
<p>Although Microsoft specifies <code>%COMSPEC%</code> must contain the path to
<code>&apos;cmd.exe&apos;</code> in the root environment, child processes are not always subject to
the same requirement. Thus, in <code>child_process</code> functions where a shell can be
spawned, <code>&apos;cmd.exe&apos;</code> is used as a fallback if <code>process.env.ComSpec</code> is
unavailable.
[<code>&apos;error&apos;</code>]: #child_process_event_error
[<code>&apos;exit&apos;</code>]: #child_process_event_exit
[<code>ChildProcess</code>]: #child_process_child_process
[<code>Error</code>]: errors.html#errors_class_error
[<code>EventEmitter</code>]: events.html#events_class_eventemitter
[<code>subprocess.connected</code>]: #child_process_subprocess_connected
[<code>subprocess.disconnect()</code>]: #child_process_subprocess_disconnect
[<code>subprocess.kill()</code>]: #child_process_subprocess_kill_signal
[<code>subprocess.send()</code>]: #child_process_subprocess_send_message_sendhandle_options_callback
[<code>subprocess.stderr</code>]: #child_process_subprocess_stderr
[<code>subprocess.stdin</code>]: #child_process_subprocess_stdin
[<code>subprocess.stdout</code>]: #child_process_subprocess_stdout
[<code>child_process.exec()</code>]: #child_process_child_process_exec_command_options_callback
[<code>child_process.execFile()</code>]: #child_process_child_process_execfile_file_args_options_callback
[<code>child_process.execFileSync()</code>]: #child_process_child_process_execfilesync_file_args_options
[<code>child_process.execSync()</code>]: #child_process_child_process_execsync_command_options
[<code>child_process.fork()</code>]: #child_process_child_process_fork_modulepath_args_options
[<code>child_process.spawn()</code>]: #child_process_child_process_spawn_command_args_options
[<code>child_process.spawnSync()</code>]: #child_process_child_process_spawnsync_command_args_options
[<code>maxBuffer</code> and Unicode]: #child_process_maxbuffer_and_unicode
[<code>net.Server</code>]: net.html#net_class_net_server
[<code>net.Socket</code>]: net.html#net_class_net_socket
[<code>options.detached</code>]: #child_process_options_detached
[<code>process.disconnect()</code>]: process.html#process_process_disconnect
[<code>process.env</code>]: process.html#process_process_env
[<code>process.execPath</code>]: process.html#process_process_execpath
[<code>process.on(&apos;disconnect&apos;)</code>]: process.html#process_event_disconnect
[<code>process.on(&apos;message&apos;)</code>]: process.html#process_event_message
[<code>process.send()</code>]: process.html#process_process_send_message_sendhandle_options_callback
[<code>stdio</code>]: #child_process_options_stdio
[<code>util.promisify()</code>]: util.html#util_util_promisify_original
[Default Windows Shell]: #child_process_default_windows_shell
[Shell Requirements]: #child_process_shell_requirements
[synchronous counterparts]: #child_process_synchronous_process_creation</p>

      </div>
    </div>

    <div id="column2" class="interior">
      <div id="intro" class="interior">
        <a href="/" title="Go back to the home page">
          Node.js 中文文档 | Node.js 中文网
        </a>
      </div>
      
        <!-- [start-include:_toc.md] -->
<ul>
<li><a href="documentation.html">关于本文档</a></li>
<li><a href="synopsis.html">用法与例子</a></li>
</ul>
<div class="line"></div>

<ul>
<li><a href="assert.html">断言测试</a></li>
<li><a href="async_hooks.html">异步钩子（Async Hooks）</a></li>
<li><a href="buffer.html">缓存（Buffer）</a></li>
<li><a href="addons.html">C++ 插件</a></li>
<li><a href="n-api.html">C/C++ 插件 - N-API</a></li>
<li><a href="child_process.html">子进程</a></li>
<li><a href="cluster.html">集群（Cluster）</a></li>
<li><a href="cli.html">命令行参数</a></li>
<li><a href="console.html">控制台（Console）</a></li>
<li><a href="crypto.html">加密（Crypto）</a></li>
<li><a href="debugger.html">调试器</a></li>
<li><a href="deprecations.html">废弃的 API</a></li>
<li><a href="dns.html">DNS</a></li>
<li><a href="domain.html">域（Domain）</a></li>
<li><a href="esm.html">ECMAScript 模块</a></li>
<li><a href="errors.html">错误（Errors）</a></li>
<li><a href="events.html">事件（Events）</a></li>
<li><a href="fs.html">文件系统</a></li>
<li><a href="globals.html">全局对象（Globals）</a></li>
<li><a href="http.html">HTTP</a></li>
<li><a href="http2.html">HTTP/2</a></li>
<li><a href="https.html">HTTPS</a></li>
<li><a href="inspector.html">检查工具（Inspector）</a></li>
<li><a href="intl.html">国际化</a></li>
<li><a href="modules.html">模块（Modules）</a></li>
<li><a href="net.html">网络（Net）</a></li>
<li><a href="os.html">操作系统（OS）</a></li>
<li><a href="path.html">路径（Path）</a></li>
<li><a href="perf_hooks.html">性能钩子（Performance Hooks）</a></li>
<li><a href="process.html">进程</a></li>
<li><a href="punycode.html">Punycode</a></li>
<li><a href="querystring.html">查询字符串</a></li>
<li><a href="readline.html">逐行读取</a></li>
<li><a href="repl.html">交互式解释器（REPL）</a></li>
<li><a href="stream.html">流（Stream）</a></li>
<li><a href="string_decoder.html">字符串解码</a></li>
<li><a href="timers.html">定时器（Timers）</a></li>
<li><a href="tls.html">安全传输层（TLS/SSL）</a></li>
<li><a href="tracing.html">事件跟踪（Tracing）</a></li>
<li><a href="tty.html">TTY</a></li>
<li><a href="dgram.html">UDP / 数据报</a></li>
<li><a href="url.html">URL</a></li>
<li><a href="util.html">工具集</a></li>
<li><a href="v8.html">V8</a></li>
<li><a href="vm.html">虚拟机（VM）</a></li>
<li><a href="zlib.html">压缩（ZLIB）</a></li>
</ul>
<div class="line"></div>

<ul>
<li><a href="https://github.com/nodejs/node">GitHub 仓库和问题跟踪</a></li>
<li><a href="https://groups.google.com/group/nodejs">邮件列表</a></li>
</ul>
<!-- [end-include:_toc.md] -->

      
    </div>
  </div>
  <script src="assets/sh_main.js"></script>
  <script src="assets/sh_javascript.min.js"></script>
  <script>highlight(undefined, undefined, 'pre');</script>
</body>
</html>
